{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b8f46f66-f828-40e1-a47e-a0362c191ba2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import PIL\n",
    "from PIL import ImageOps\n",
    "from PIL import Image as PILImage\n",
    "import numpy as np\n",
    "import random\n",
    "from IPython.display import display, Image\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision import transforms\n",
    "import torch.multiprocessing\n",
    "from torch.multiprocessing import freeze_support"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "27c5c4de-d322-4aba-ae56-56e1cda0ede1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据集获取\n",
    "class OxfordPetsDataset(Dataset):\n",
    "    def __init__(self, input_img_paths, target_img_paths, img_size, transform=None):\n",
    "        self.input_img_paths = input_img_paths\n",
    "        self.target_img_paths = target_img_paths\n",
    "        self.img_size = img_size\n",
    "        self.transform = transform\n",
    "        self.image_transform = transforms.Compose([\n",
    "            transforms.Resize(img_size),\n",
    "            transforms.ToTensor(), # 将PILImage转换为Tensor，并归一化到[0,1]\n",
    "            # transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # 通常在ImageNet预训练模型中使用，如果从头训练可以不加\n",
    "        ])\n",
    "        self.mask_transform = transforms.Compose([\n",
    "            transforms.Resize(img_size, interpolation=transforms.InterpolationMode.NEAREST), # mask使用最近邻插值\n",
    "            transforms.ToTensor(), # 将PILImage转换为Tensor\n",
    "        ])\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.input_img_paths)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        # 加载输入图像\n",
    "        img_path = self.input_img_paths[idx]\n",
    "        img = PILImage.open(img_path).convert(\"RGB\")\n",
    "        img = self.image_transform(img)\n",
    "\n",
    "        # 加载目标（标注）图像\n",
    "        mask_path = self.target_img_paths[idx]\n",
    "        mask = PILImage.open(mask_path).convert(\"L\") # 确保是灰度图\n",
    "        mask = self.mask_transform(mask)\n",
    "        # trimaps通常包含像素值1, 2, 3。对于`CrossEntropyLoss`，目标需要0-indexed。\n",
    "        # 如果您的trimaps是1,2,3，则需要减1，变成0,1,2。\n",
    "        # 如果原始Keras代码中num_classes=4意味着0,1,2,3，且trimaps是0,1,2,3，则不需要减1。\n",
    "        # 在Oxford-IIIT Pet Dataset的trimaps中，通常是1, 2, 3。因此这里减1。\n",
    "        mask = (mask * 255).long() - 1 # 转换为long类型，并调整值使其从0开始\n",
    "\n",
    "        return img, mask.squeeze(0) # 移除通道维度，因为CrossEntropyLoss期望 (N, H, W) 或 (N, C, H, W)\n",
    "\n",
    "# 构建Unet网络\n",
    "class DownsamplingBlock(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels):\n",
    "        super().__init__()\n",
    "        print(f\"Initializing DownsamplingBlock with in_channels={in_channels}, out_channels={out_channels}\") # Debug init\n",
    "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)\n",
    "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
    "        self.relu1 = nn.ReLU(inplace=True)\n",
    "\n",
    "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)\n",
    "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
    "        self.relu2 = nn.ReLU(inplace=True)\n",
    "\n",
    "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # print(f\"DownsamplingBlock: Input x.shape = {x.shape}\") # Debug\n",
    "\n",
    "        # First convolution block\n",
    "        x_after_conv1 = self.conv1(x)\n",
    "        # print(f\"DownsamplingBlock: After conv1, x.shape = {x_after_conv1.shape}\") # Debug\n",
    "\n",
    "        x_after_bn1 = self.bn1(x_after_conv1)\n",
    "        # print(f\"DownsamplingBlock: After bn1, x.shape = {x_after_bn1.shape}\") # Debug\n",
    "\n",
    "        x_after_relu1 = self.relu1(x_after_bn1)\n",
    "        # print(f\"DownsamplingBlock: After relu1, x.shape = {x_after_relu1.shape}\") # Debug\n",
    "\n",
    "        # Second convolution block\n",
    "        x_after_conv2 = self.conv2(x_after_relu1) # THIS IS WHERE THE ERROR IS ACTUALLY POINTING TO THE WEIGHTS\n",
    "        # print(f\"DownsamplingBlock: After conv2, x.shape = {x_after_conv2.shape}\") # Debug\n",
    "\n",
    "        x_after_bn2 = self.bn2(x_after_conv2)\n",
    "        # print(f\"DownsamplingBlock: After bn2, x.shape = {x_after_bn2.shape}\") # Debug\n",
    "\n",
    "        features = self.relu2(x_after_bn2)\n",
    "        # print(f\"DownsamplingBlock: After relu2 (features), features.shape = {features.shape}\") # Debug\n",
    "\n",
    "        pooled = self.pool(features)\n",
    "        # print(f\"DownsamplingBlock: Pooled output, pooled.shape = {pooled.shape}\") # Debug\n",
    "\n",
    "        return pooled, features\n",
    "\n",
    "class UpsamplingBlock(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels):\n",
    "        super().__init__()\n",
    "        # PyTorch的ConvTranspose2d会自动处理步长引起的尺寸放大\n",
    "        self.up = nn.ConvTranspose2d(in_channels, out_channels, kernel_size=2, stride=2)\n",
    "        \n",
    "        # 拼接后的通道数是 up 的 out_channels + skip_tensor 的 out_channels\n",
    "        # skip_tensor 的 out_channels 应该和当前 up_block 的 out_channels 相同\n",
    "        # 所以拼接后的通道数是 out_channels + out_channels = 2 * out_channels\n",
    "        self.conv_block = nn.Sequential(\n",
    "            nn.Conv2d(out_channels * 2, out_channels, kernel_size=3, padding=1), \n",
    "            nn.BatchNorm2d(out_channels),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(out_channels),\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "\n",
    "    def forward(self, input_tensor, skip_tensor):\n",
    "        # print(f\"UpsamplingBlock input_tensor shape: {input_tensor.shape}, skip_tensor shape: {skip_tensor.shape}\") # Debug\n",
    "        x = self.up(input_tensor)\n",
    "        # print(f\"UpsamplingBlock after upsample: {x.shape}\") # Debug\n",
    "        \n",
    "        # 处理裁剪以匹配尺寸\n",
    "        # 如果上采样后的x比skip_tensor小，需要填充\n",
    "        # 如果上采样后的x比skip_tensor大，通常是错误，但如果设计如此，需要裁剪\n",
    "        diffY = skip_tensor.size()[2] - x.size()[2]\n",
    "        diffX = skip_tensor.size()[3] - x.size()[3]\n",
    "\n",
    "        # 检查是否需要填充或裁剪，并确保尺寸匹配\n",
    "        if diffY < 0 or diffX < 0: # 如果上采样结果比跳跃连接大，这通常是模型设计或计算错误\n",
    "            # 这种情况比较少见，如果发生了，可能需要裁剪x\n",
    "            # 或者重新审视网络结构和尺寸计算\n",
    "            # 为简单起见，这里假设skip_tensor总是大于或等于x\n",
    "            print(f\"Warning: Up-sampled tensor {x.shape} is larger than skip connection {skip_tensor.shape}. Cropping up-sampled tensor.\")\n",
    "            x = transforms.CenterCrop((skip_tensor.size()[2], skip_tensor.size()[3]))(x)\n",
    "        else: # skip_tensor 大于或等于 x，进行填充\n",
    "            x = F.pad(x, [diffX // 2, diffX - diffX // 2,\n",
    "                            diffY // 2, diffY - diffY // 2])\n",
    "        # print(f\"UpsamplingBlock after padding/cropping: {x.shape}\") # Debug\n",
    "\n",
    "        # 拼接跳跃连接\n",
    "        x = torch.cat([x, skip_tensor], dim=1) # 在通道维度拼接\n",
    "        # print(f\"UpsamplingBlock after concat: {x.shape}\") # Debug\n",
    "        x = self.conv_block(x)\n",
    "        # print(f\"UpsamplingBlock output: {x.shape}\") # Debug\n",
    "        return x\n",
    "\n",
    "class UNet(nn.Module):\n",
    "    def __init__(self, in_channels=3, num_classes=4, features=64, depth=3):\n",
    "        super().__init__()\n",
    "        self.down_blocks = nn.ModuleList()\n",
    "        self.up_blocks = nn.ModuleList()\n",
    "\n",
    "        # 编码器 (下采样路径)\n",
    "        prev_features = in_channels # 跟踪前一个块的输出特征数\n",
    "        for i in range(depth):\n",
    "            current_out_features = features * (2 ** i) # 计算当前块的输出特征数\n",
    "            self.down_blocks.append(DownsamplingBlock(prev_features, current_out_features))\n",
    "            prev_features = current_out_features # 更新 prev_features 为当前块的输出特征数\n",
    "\n",
    "        # 瓶颈层\n",
    "        # bottleneck的in_channels应该是最后一个down_block的输出，也就是prev_features\n",
    "        # bottleneck的out_channels通常是prev_features的2倍\n",
    "        self.bottleneck = nn.Sequential(\n",
    "            nn.Conv2d(prev_features, prev_features * 2, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(prev_features * 2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(prev_features * 2, prev_features * 2, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(prev_features * 2),\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "        \n",
    "        # 为解码器准备 prev_features，使其从瓶颈层的输出开始\n",
    "        prev_features_for_up = prev_features * 2 # 瓶颈层的输出通道数\n",
    "\n",
    "        # 解码器 (上采样路径)\n",
    "        for i in reversed(range(depth)): # i = 2, 1, 0\n",
    "            current_up_out_features = features * (2 ** i) # 对应下采样块的输出特征数\n",
    "            # UpsamplingBlock的in_channels是来自前一层（上采样或瓶颈）的输出通道数\n",
    "            # UpsamplingBlock的out_channels是当前层卷积块的输出通道数\n",
    "            self.up_blocks.append(UpsamplingBlock(prev_features_for_up, current_up_out_features))\n",
    "            prev_features_for_up = current_up_out_features # 更新 prev_features_for_up\n",
    "\n",
    "        # 输出层\n",
    "        self.final_conv = nn.Conv2d(features, num_classes, kernel_size=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # print(f\"UNet input shape: {x.shape}\") # Debug\n",
    "        skips = []\n",
    "        # 编码器\n",
    "        for down_block in self.down_blocks:\n",
    "            x, skip = down_block(x)\n",
    "            skips.append(skip)\n",
    "        \n",
    "        # 瓶颈\n",
    "        # print(f\"UNet before bottleneck: {x.shape}\") # Debug\n",
    "        x = self.bottleneck(x)\n",
    "        # print(f\"UNet after bottleneck: {x.shape}\") # Debug\n",
    "        \n",
    "        # 解码器\n",
    "        for i, up_block in enumerate(self.up_blocks):\n",
    "            # skips是按照编码顺序存储的，解码时反向取\n",
    "            x = up_block(x, skips[-(i + 1)])\n",
    "        \n",
    "        # 最终卷积\n",
    "        logits = self.final_conv(x)\n",
    "        # CrossEntropyLoss内部会进行softmax，所以这里可以不加softmax\n",
    "        # 但如果需要模型直接输出概率图，则可以加上\n",
    "        # output = F.softmax(logits, dim=1) \n",
    "        # print(f\"UNet final output shape: {logits.shape}\") # Debug\n",
    "        return logits\n",
    "\n",
    "\n",
    "# 定义预测结果显示方法\n",
    "def display_mask(i, val_preds, img_size, num_classes):\n",
    "    if i >= len(val_preds):\n",
    "        print(f\"Index {i} is out of bounds for val_preds (length {len(val_preds)})\")\n",
    "        return\n",
    "    \n",
    "    mask = val_preds[i] # 此时mask已经是 (H, W) 的numpy数组\n",
    "    \n",
    "    # 假设你的原始trimaps是1, 2, 3，并且你的模型预测是0, 1, 2\n",
    "    # 你可能需要将预测结果+1，然后进行可视化\n",
    "    mask_for_display = (mask + 1).astype(np.uint8) # 转换回1, 2, 3\n",
    "    # 或者直接使用0,1,2然后让ImageOps.autocontrast处理\n",
    "    # mask_for_display = mask.astype(np.uint8)\n",
    "\n",
    "    # PIL Image接受0-255的灰度图像\n",
    "    img = PILImage.fromarray(mask_for_display * (255 // (num_classes -1))) # 简单的归一化到0-255，假设num_classes是3或4\n",
    "    img = PIL.ImageOps.autocontrast(img)\n",
    "    display(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e8288075-da01-4e86-8cda-1ec7b42c8c15",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 图片位置\n",
    "input_dir = \"dataset/images/\"\n",
    "# 标注位置\n",
    "target_dir = \"dataset/annotations/trimaps\"\n",
    "img_size = (160, 160)\n",
    "batch_size = 32\n",
    "num_classes = 4 # Keras中是4，但在trimaps中，通常是1, 2, 3，分别代表前景、背景、边框。如果您的trimaps是0-indexed，那么num_classes可以是3。这里我保留4以匹配原始代码，但请注意softmax输出的通道数会是4。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cf8c27b4-dc2c-460e-aaa5-7996d35b0274",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=600x400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 图片的路径\n",
    "input_img_paths = sorted([os.path.join(input_dir, fname) for fname in os.listdir(input_dir) if fname.endswith('.jpg')])\n",
    "# 标注的路径\n",
    "target_img_paths = sorted([os.path.join(target_dir, fname) for fname in os.listdir(target_dir) if fname.endswith('.png') and not fname.startswith('.')])\n",
    "\n",
    "# 展示第一个图像 (PyTorch中可以直接用PILImage)\n",
    "if input_img_paths:\n",
    "    display(PILImage.open(input_img_paths[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "408379cf-fdfb-4026-8713-21462f5cbca3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=600x400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    " # 显示标注图像\n",
    "if target_img_paths:\n",
    "    img = PILImage.open(target_img_paths[0]).convert('L') # 确保是灰度图\n",
    "    img = ImageOps.autocontrast(img)\n",
    "    display(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "83413eab-c57b-4d6f-8768-24e482e304fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: npu\n"
     ]
    }
   ],
   "source": [
    "import torch_npu\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")\n",
    "elif hasattr(torch, \"npu\") and torch.npu.is_available():  # 华为Ascend NPU\n",
    "    device = torch.device(\"npu\")\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "print(f\"Using device: {device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "daa42f8a-9d93-4a53-8d4d-9212d5a31805",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing DownsamplingBlock with in_channels=3, out_channels=64\n",
      "Initializing DownsamplingBlock with in_channels=64, out_channels=128\n",
      "Initializing DownsamplingBlock with in_channels=128, out_channels=256\n"
     ]
    }
   ],
   "source": [
    "# 构建模型\n",
    "model = UNet(in_channels=3, num_classes=num_classes).to(device) # 将模型移动到指定设备"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5005f442-10e1-4d5a-932f-c919478ba773",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将数据集划分为训练集和验证集\n",
    "val_samples = 1000\n",
    "random.Random(1337).shuffle(input_img_paths)\n",
    "random.Random(1337).shuffle(target_img_paths)\n",
    "\n",
    "train_input_img_paths = input_img_paths[:-val_samples]\n",
    "train_target_img_paths = target_img_paths[:-val_samples]\n",
    "\n",
    "val_input_img_paths = input_img_paths[-val_samples:]\n",
    "val_target_img_paths = target_img_paths[-val_samples:]\n",
    "\n",
    "# 获取训练集和验证集DataLoader\n",
    "train_dataset = OxfordPetsDataset(train_input_img_paths, train_target_img_paths, img_size)\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=os.cpu_count() // 2 or 1) # num_workers可以根据CPU核心数调整\n",
    "\n",
    "val_dataset = OxfordPetsDataset(val_input_img_paths, val_target_img_paths, img_size)\n",
    "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=os.cpu_count() // 2 or 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "57be73dd-78fe-466e-82bc-2c30f195370c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/15, Train Loss: 0.7190\n",
      "Epoch 1/15, Validation Loss: 0.6342\n",
      "Epoch 2/15, Train Loss: 0.5598\n",
      "Epoch 2/15, Validation Loss: 0.5884\n",
      "Epoch 3/15, Train Loss: 0.4820\n",
      "Epoch 3/15, Validation Loss: 0.4672\n",
      "Epoch 4/15, Train Loss: 0.4234\n",
      "Epoch 4/15, Validation Loss: 0.4598\n",
      "Epoch 5/15, Train Loss: 0.3933\n",
      "Epoch 5/15, Validation Loss: 0.3783\n",
      "Epoch 6/15, Train Loss: 0.3635\n",
      "Epoch 6/15, Validation Loss: 0.4200\n",
      "Epoch 7/15, Train Loss: 0.3459\n",
      "Epoch 7/15, Validation Loss: 0.4445\n",
      "Epoch 8/15, Train Loss: 0.3347\n",
      "Epoch 8/15, Validation Loss: 0.3317\n",
      "Epoch 9/15, Train Loss: 0.3164\n",
      "Epoch 9/15, Validation Loss: 0.3418\n",
      "Epoch 10/15, Train Loss: 0.3075\n",
      "Epoch 10/15, Validation Loss: 0.4115\n",
      "Epoch 11/15, Train Loss: 0.2931\n",
      "Epoch 11/15, Validation Loss: 0.3883\n",
      "Epoch 12/15, Train Loss: 0.2853\n",
      "Epoch 12/15, Validation Loss: 0.3143\n",
      "Epoch 13/15, Train Loss: 0.2780\n",
      "Epoch 13/15, Validation Loss: 0.3001\n",
      "Epoch 14/15, Train Loss: 0.2710\n",
      "Epoch 14/15, Validation Loss: 0.3684\n",
      "Epoch 15/15, Train Loss: 0.2577\n",
      "Epoch 15/15, Validation Loss: 0.3183\n"
     ]
    }
   ],
   "source": [
    " # 编译模型 (PyTorch中是定义优化器和损失函数)\n",
    "optimizer = torch.optim.RMSprop(model.parameters(), lr=1e-3) # Keras的rmsprop默认lr是0.001\n",
    "criterion = nn.CrossEntropyLoss() # 适用于多分类分割，自动处理softmax和one-hot编码\n",
    "\n",
    "# 模型训练\n",
    "epochs = 15\n",
    "print(\"开始训练\")\n",
    "for epoch in range(epochs):\n",
    "    model.train() # 设置为训练模式\n",
    "    running_loss = 0.0\n",
    "    for batch_idx, (inputs, masks) in enumerate(train_loader):\n",
    "        inputs = inputs.to(device)\n",
    "        masks = masks.to(device)\n",
    "\n",
    "        optimizer.zero_grad() # 清除之前的梯度\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, masks) # 计算损失\n",
    "        loss.backward() # 反向传播\n",
    "        optimizer.step() # 更新权重\n",
    "\n",
    "        running_loss += loss.item()\n",
    "\n",
    "    print(f\"Epoch {epoch+1}/{epochs}, Train Loss: {running_loss / len(train_loader):.4f}\")\n",
    "\n",
    "    # 验证\n",
    "    model.eval() # 设置为评估模式\n",
    "    val_loss = 0.0\n",
    "    with torch.no_grad(): # 在验证时禁用梯度计算\n",
    "        for inputs, masks in val_loader:\n",
    "            inputs = inputs.to(device)\n",
    "            masks = masks.to(device)\n",
    "\n",
    "            outputs = model(inputs)\n",
    "            loss = criterion(outputs, masks)\n",
    "            val_loss += loss.item()\n",
    "    print(f\"Epoch {epoch+1}/{epochs}, Validation Loss: {val_loss / len(val_loader):.4f}\")\n",
    "print(\"训练结束。。\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "19481f73-9036-414c-a7b5-5953486d173c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=279x300>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCAEsARcBAREA/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/9oACAEBAAA/AL+vf8jDqf8A19y/+hms+iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiitDXv8AkYdT/wCvuX/0M1n0UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVoa9/wAjDqf/AF9y/wDoZrPooooooooooooooooooooooooooooooooorQ17/kYdT/6+5f8A0M1n0UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVoa9/yMOp/9fcv/AKGaz6KKKKKKKKKKKK3PDvhi68QzOUbyLWPh52XIz2UDjJ/kPwz6Rp3hHRdOhKCyjuGP3pLlRIx6+owOvYDtVz+wdH/6BNj/AOA6f4Uf2Do//QJsf/AdP8KP7B0f/oE2P/gOn+FV7rwroV3s8zTIF25x5QMfX124z+NV/wDhCPDv/QP/API0n/xVH/CEeHf+gf8A+RpP/iqq3Pw+0OeQNGLm3AGNkUuQff5gT+tV5PhvpRjYR3d4rkHaWZSAe2RtGfzFczq/gXVNNzJbD7dB6xL846dU69T2z0ycVy9FFFFFFFFFaGvf8jDqf/X3L/6Gaz6KKKKKKKKKKK9E8K+CI1hW+1mHdI2Gjtm6IOuXHc/7J4x154HVarrOkeGdK+16neW1hZRDapkYKOFJCIOrHCnCqCTjgV83eKPj/wCKNR1Rz4fkj0rT0dhEDAkksi8YMhcMAeCcLjG7BLYBrD/4Xb8Q/wDoYf8AySt//jdH/C7fiH/0MP8A5JW//wAbo/4Xb8Q/+hh/8krf/wCN1oaZ8fvHNh5v2m4sdS342/a7UL5eM5x5RTrnvnoMY5zof8NHeMP+gbof/fib/wCO0f8ADR3jD/oG6H/34m/+O1sWP7S95HZxrf8AhiCe6Gd8kF4Ykbk4wpRiOMfxH146Vfsf2l7OS8jW/wDDE8Fqc75ILwSuvBxhSig84/iHrz0r1Twp488OeM7cPo2oxyThN0lpJ8k8fC5yh5IBYDcMrngE1uXVhZ3uz7XaQXGzO3zYw+3PXGenQVyep/DqxnV306aS2l6rG53x9On94ZOOcnvxXA6ppF7o900F5CyHJCvg7JMd1PfqPpnnFUaKKKKKKmu7l7y9nupAoeaRpGC9AScnH51DRRRRRRRRRRXZfDzS4LzUri8nVXNoF8tGGcOxOG/Dafzz2rvtcuNRtNDvZ9IsvtupLE32aAlQHkPC7izKNoOCeQcA45wK+JPEOq61q+szz+ILm7n1BHaOQXWQ0RDElAp+4Axb5QABzwKy6KKKKKKKKK7jRvi9450TYsWvT3UIlErR3wFxv6ZUs+XCkDorDqSME5r1fwj+0Tp15ttvFdn/AGfNz/plorPCfvHlOXXgKON+SSflFeySwafrenIXWC8s5kEkbgh1YEcMrD2PBHrxXA638PZ7SN7jS5muI1GTC4/edumOG7nHHoMmuJooooooooooooooooorQ0bWbrQ777XaeWXKFGWRcqwPY9+oB4PavTvD/jCy12T7Psa2u8EiJ2BDdfunvxyRgfjgmuN+OfgmHxD4Om1q2t4/7U0pPN8wABpLcZMiEkgYAJcZyflIA+Y18qUUUUUUUUUUUV1ngz4jeI/AruukXMbWkr75bO4TfE7bSM4yCp6cqRnaucgYr7D0LU/7b8PaZq3k+T9utIrnyt27ZvQNtzgZxnGcCvJ/FVlDp/ia+t7ddsQcMq4AC7lDYGOgGcD2rHoooooooooooooooooroPBH/I32P/bT/wBFtXoHjv8A5J54l/7BV1/6KaviCiiiiiiiiiiipIIJrq4it7eKSaeVwkccalmdicAADkknjFfc/hrTZtG8K6Rpdw0bT2VlDbyNGSVLIgUkZAOMj0FeY+NJEk8XX7RurAFFypzyEUEfgQRWDRRRRRRRRRRRRRRRRRXSeBIJJfFls6LlYUd3Oeg2lc/mw/Ou4+IM8Nt8OfEjzyxxIdMuEDOwUFmjKqOe5YgAdyQK+JKKKKKKKKKK9o+AngKz1+8vtf1iygu7C1/0a3hnQOjzEAsxUn+FSOGUg+ZkcrX0PrOh6X4h057DV7CC9tWydkyZ2kgjcp6q2CcMMEZ4Ncn4S+E3hzwb4lu9Z09JJHlQLbJcHebTJbfsb0KlV5BYBT8x3Gtjxf4k/sOxEds8ZvpuEU8lF5y+P0Ge/rgivJZJHlkaSR2d3JZmY5JJ6kmm0UUUUUUUUUUUUUUUUV6p8P8ATGstCa6lj2y3b7xnOfLHC5B/4EeOoIry/wDaN8VzQpp/hS3MiJMgvbphkB13FY04PI3KzEEdQhB4NfPlFFFFFFFFFe//ALMv/M0/9un/ALWr2DxfrN1oemW93aeWXNwEZZFyrAq3B79QDwe1YcPxKh+w5m0+Q3gwNqOBG3TJyeV78YPbmuDvr2bUb6e8uGzLM5ZuTgewz2HQewqvRRRRRRRRRRRRRRRRU1taXN5IY7W3lncDcViQsQPXA+tdlovw9unuIptXMcduMloEfLsQeASOAD1yCT9O3Za/rmneEfDd1q18GjsbKMZSGPJ6hVVQOOSQB0AzyQOa+LvFXiG48V+KNR1y6XZJdylwmQfLQDCJkAZ2qFGcc4yeax6KKKKKKKKK9/8A2Zf+Zp/7dP8A2tXqHxH/AORet/8Ar7X/ANAevL6KKKKKKKKKKKKKK1NC0K616+FvbjbGuDLMR8sY/qfQd/pkjuo/hvpQjUSXd4zgDcVZQCe+BtOPzNUb74a/6xrDUPTZHOn0zlh+P8Pt71a0v4dWkDLJqVw1ycD91GCiA45yc5PPTp0/CuusrG1063FvZwRwxD+FBjJxjJ9TwOTzXD638afA2ieen9r/AG+4h2/ubCMy784+7JxGcA5PzdiOvFfNnjn4g61461SSe+nkhsA4Nvp6SExQgZAOOjPhjlyMnJxgYA5Oiiiiiiiiiivf/wBmX/maf+3T/wBrV6h8R/8AkXrf/r7X/wBAevL6KKKKKKKKKKKKKK9c8EaYun+HYZWj2z3X75ycEkH7vI7bcHB6FjXF+P8A43W/gnxQ+hwaN/aUkMSPO/2ow+W7DITBjOflKnIP8WOoNGjftB+DtQ2JqK32lyeUHdpofNjD8ZRTHlj1OCVGQOx4rP8AE/7ROhWMU0Hhyzn1K6HEc8ymKDlc7sH52w2AVIXPOGHBPjHi74neKfGm6LUr7yrE4/0G0Bjh/h6jJL8qG+Ytg5xiuPoooooooooooor3/wDZl/5mn/t0/wDa1eofEf8A5F63/wCvtf8A0B68voooooooooooooq5pMEdzrNjbzLuiluI0dc4yCwBHFe6V8EX99canqNzf3knmXV1K80z7QNzsSWOBwMknpVeiiiiuo8KfD3xL40iuJtFsPNt7fIeeSRY03hSwQEnljgDjpuXcVBzWHqulX2h6pcaZqdtJbXlu+yWJ+qn+RBGCCOCCCMg1Toooooooor3D9mvU/K8Q65pPk5+02iXPm7vu+U+3bjHOfOznPG3vnj2fx/a/aPC7yb9v2eVJMYzuydmPb72fwryeiiiiiiiiiiiiiuo8A2U1x4miuEX91bIzSMQccqVA+vOfoD6V1nxO1KHSvhl4iuJ1kZHsntwEAJ3SjylPJHG5wT7Z69K+LKKKKKK+p/2fNTs7v4dNYwwwQ3VldyLcBGG+Xd8yyMAMjIOwE5z5XXjA5v9pDw5NMmkeIraxkdIUe2vblSSEXcDEGGeBuaT5sdSATyor58ooooooooruPhDrP8AYnxQ0WVnnENzKbORIT9/zQUUMMjKhyjH/dzgkCvrvVrL+0dIu7MLGWmiZU8wfKGx8pP0OD+FeF0UUUUUUUUUUUU6ON5ZFjjRndyFVVGSSegAr2bwxpH9i6FDbOMTt+8m/wB89R1I4AA464z3rwT9ofxbNeeILfwrBNGbOyRLi4QRkN9oYNgFj1AjZSNvHznOSBjxOiiiiivXP2f/ABXDofjGfRroxpBrCKiSNgbZk3FBkkDDBnXGCSxQDvX0vqulWOuaXcaZqdtHc2dwmyWJ+jD+YIOCCOQQCMEV8qfED4Pa74QvLm6sLafUdCXLpdRqGeJcEkSqORtCnL429DwTtHm9FFFFFFFFfZ/wx8Xf8Jp4GstSlbdfRf6Ne8Y/fIBlvugfMCr4AwN2O1c74/0g2esfboYWW3ugCzgDaJecjjpkAHnqSffHI0UUUUUUUUUUV2ngLw/Jc3y6tcxYtYc+Tu/jk6ZAI5A5545xjoa1Pin46TwL4SkuIjnU7zdBZKGXKuVP70hs5VOCeDklQcbsj48nnmuriW4uJZJp5XLySSMWZ2JySSeSSec1HRRRRRRX1v8ACH4kf8Jzob22pTQDXbPiZE+Uzx8YmC4wMk4IXIB5+UMor0ivJ/iB8DtL8V3lzq+k3P8AZmrTZeRSuYJ3weWA5VmO3LDPQnaSSa8M1v4T+N9DuPKm8P3d0jO6xy2CG4Vwp+98mSoOQRuCk+nBxxdFFFSQQTXVxFb28Uk08rhI441LM7E4AAHJJPGK6zxJ8L/F3hTR49V1bS/LtDgSPFKknkMWKgPtJxnAORlfmUZ3HFcfXsH7O2p6jb+ObvTbaHzbG7tDJd/Mq+V5Z+STkZbl9m0H/lpk/dr3/wAa/Y/+EXuvtnt5OMbvMz8uM/jnHO3dXj9FFFFFFFFFFbnhC0tb7xNawXaeZGdzCMrlWIUkA89OM984xjBr16SS2sLJpJHitrW3jLMzEIkaKOST0AAH4Yr42+JHjq48eeKJb7M8emxfu7G1lYHykwMnA43MRuPXsMkKK4+iiiiiiitDQ9ZvPD2uWWr2D7Lq0lWVMkgNjqrYIJUjIIzyCRX2H8PPHEPj/wANNq0VjJZPHcPbywtIHAYBWyrYGRtZeoHOR2yesoqnqWk6brNutvqmn2l9Arh1juoVlUNgjIDAjOCRn3NZf/CCeD/+hU0P/wAF0P8A8TR/wgng/wD6FTQ//BdD/wDE0f8ACCeD/wDoVND/APBdD/8AE1JbeDfDNjf21/ZaBptpd2zl4prW2WJgSjIclQMjax4OR0PUAjg/jz4us9H8Fy6CrQS6lqm1RC4DGOEHLSFSpHVdoPBydynKcfLFfS/7OGjfZPCWp6u6TpJf3YiXeMI8cS8MvHPzPICckfLjgg13HxH/AORet/8Ar7X/ANAevL6KKKKKKKKKK9I+HWkeTZy6tIPnnzHF/uA8nr3YY5H8PvXL/H7xl/YvhePw9Zzbb7Vf9dsbDR24PzZwwI3nC8ghlEgr5gooooooooor63+BV9b3fwo02GCTfJaSzwzjaRscyNIBz1+V1PHr65r0iiiiiiqeq6rY6Hpdxqep3MdtZ26b5ZX6KP5kk4AA5JIAyTXyR8VvHtt4+8SwXlhaSW9nbW4hj89EErnJZixXJxk4C7iBgkYLEVwdfa/w4sbfT/hr4chtY/LjbT4ZiNxOXkUSOefVmY+2eOKr/Ef/AJF63/6+1/8AQHry+iiiiiiiiitDRdJm1vVIrKE7N2S8hUkIo6k4/L6kCvZIIrPRNIVDJHBZ2kWXkkIVVVRlmY8AdyT9TXxh488VzeM/GN/rLmQQO+y1jfP7uFeEGMkA4+YgHG5mI61zdFFFFFFFFFemfCD4mL4F1Sax1MSPot86mVlLMbZxx5gXoQRgMAMkBSM7dp+p9K1Wx1zS7fU9MuY7mzuE3xSp0YfzBByCDyCCDgirlFFFFfMHxx+JFn4qvLfQNGm87TbCUyTXC4KTzY2jYcZ2qCw3A4bceCApPj9ekfBTwfb+K/HIfUbbz9N06I3EqPEWjkfICIxzgZJLYOdwjIwRmvreuJ+JVyi6VZ2pDb5JzID2wqkH/wBDH615rRRRRRRRRRXonw30xkhutTkjx5mIYWOQSBy3sRnaM+qmuX/aD8XNpPhq10CxvZIbzUXLXCxMuTbAEFW53AMxAGBhgjgnGQfmSiiiiiiiiiiivrv4L+FV8NfD6znaaSS41VFvpR5rNGocZQKpwFOzbuOMk9yAuPRKKKx/Fes/8I94S1bVw8CSWlpJLF55wjSBTsU8jOW2jAOTnA5r5Q8T/Fvxj4qimtrrU/stjNw1pZL5SEbdpUnl2UgnKsxBz04GOHor6v8AgN4d/sX4dRX0sWy61WVrli8OxxGPljUnqy4BcHp+849T6hXi/ifV/wC2tdmuUOYF/dw/7g6HoDySTz0zjtWPRRRRRRRRRXtHhW1+yeF9Oj3790QkzjH3zvx+G7H4V82ftBalDffE028SyB7Cyit5SwGCxLS5XnptkUc45B+p8rooooooooooor7D+EPiix8R/D7TIbeSNbvTbeOzurcPloyg2qx4HDKu4duoySprvKKK8X/aJ8TpY+F7Tw5BPi61CUSzxrtP7hDkbs8rl9pBA52MM8EH5oorpPAfhSbxn4xsNGQSCB333UiZ/dwry5zggHHygkY3MoPWvteCCG1t4re3ijhgiQJHHGoVUUDAAA4AA4xWP4u1NtK8O3EscmyeXEMR5zluuCOhC7iD6ivG6KKKKKKKKKK9o8LXsN74asWhbPlRLC4JGVZQAc46dM/Qivmj496Neaf8TLnUZk/0XUoo5beQA4OxFjZSSMbgVyQM4DL615fRRRRRRRRRRRXQeE/Gmu+CtRa80W78rzdonhdQ8cyqcgMp/EZGGAJwRk16B/w0d4w/6Buh/wDfib/47R/w0d4w/wCgbof/AH4m/wDjtH/DR3jD/oG6H/34m/8AjteZ6/4j1fxTqjalrV9Jd3ZQJvYBQqjoFVQAo6nAA5JPUmsuivrP4JeCZvCXg5rrULeSDVNUcSzxyAq0Ua5EaEZIzgs3QEb8EfLXplee/EfVkdrfSY9rFD58p67TghR144JJBHda4GiiiiiiiiiivRPhnPI1vqNuW/dI8bquOhYMCf8Ax0flXL/tIQQt4F0y4aKMzpqaokhUblVopCwB6gEqpI77R6V8yUUUUUUUUUUUUUUUUUV7h8Efhb/aktp4y1dsWcMvmafAj8yyI2PMYjoqspwvUkc/KMN9H157428Uzw6gljpl20fkhvPeJurkEbenYZ6HqexWuDkkeWRpJHZ3clmZjkknqSabRRRRRRRRRRXXfDu7EPiGSB5WUTwMFTnDOCCPyAbk+/rXTfEvQL7xR8PNX0fTFja8nSNokdtocpIr7c9ASFIGcDJGSBzXxpfWF5pl5JZ39pPaXUeN8M8ZjdcgEZU8jIIP41Xoooooooooooooooor73sLG30zTraws4/LtbWJIYU3E7UUAKMnk4AHWsHxh4mOhWqQW203s4O0kg+Uv94j+Xbg+mD5PJI8sjSSOzu5LMzHJJPUk02iiiiiiiiiiipIJ5La4iuIW2yxOHRsZwQcg817F4c8Qwa7p8bl4kvAD5sCtyuDjIB5wcg9+uM5FUfHXgXS/Hmhmwvx5VxHlrW7Rcvbue49VOBle+OxAI+QPE/hjVPCOuTaRq8HlXEfKsvKSoejoe6nB/IggEEDHoooooooooooooorQ0PRrzxDrllpFgm+6u5ViTIJC56s2ASFAySccAE190xx21hZLHGkVta28YVVUBEjRRwAOgAA/DFeJ6zqB1TWLu9JYiWQlNwAIQcKDj0AAqjRRRRRRRRRRRRRRXpngnxVJqP/ABLL9t1yiZimZuZAOx9WHXPcA56ZPP8Axz8Ew+IfB02tW1vH/amlJ5vmAANJbjJkQkkDABLjOT8pAHzGvliCCa6uIre3ikmnlcJHHGpZnYnAAA5JJ4xX034N+AOhaL5V54hl/te+XDeTgrbRt8pxt6yYIYZbCsDyleqabpOm6Nbtb6Xp9pYwM5do7WFYlLYAyQoAzgAZ9hWf4o8I6L4x0t7DWLKOYFGWKcKBLATg7o3xlTlV9jjBBHFfFGrabNo2s32l3DRtPZXElvI0ZJUsjFSRkA4yPQVToooooorY8MeGNU8Xa5DpGkQebcScszcJEg6u57KMj8wACSAfb7z9muzGhhbLxBO2rruJkmhAgk67V2jLJ/DltzdCdvOB8+TwTWtxLb3EUkM8TlJI5FKsjA4IIPIIPGK9o/Zv0SG78S6vrMvls9hbpFEjRhiGlJ+dW/hIWNl4HIc8+vtvjy9ez8MSJHuBuZFh3K2NoOWP1yFIx715LRRRRRRRRRRRRRRRXQeCP+Rvsf8Atp/6LavQPHf/ACTzxL/2Crr/ANFNXxx4TvrfTPGWh395J5dra6hbzTPtJ2osiljgcnAB6V9z14/rWr+I7XVJbW91OdZ4cKfIk2KR1BwuByDnkZ9a9gr4g8d/8lD8S/8AYVuv/RrVz9amm+Gte1m3a40vRNSvoFco0lravKobAOCVBGcEHHuKuf8ACCeMP+hU1z/wXTf/ABNH/CCeMP8AoVNc/wDBdN/8TR/wgnjD/oVNc/8ABdN/8TXQeG/gx418R+Y39m/2XCmR5mp7oNzDHAXaXPB67dvBGcjFej2P7NFnHeRtf+J557UZ3xwWYiduDjDF2A5x/CfTjrXsHh7wroXhSzNroemQWUbffKAl5MEkbnOWbG44yTjOBxWla3cF7bie2lWWIlgHXocEg49eQea+Uvjn4XXw98QZru3jkFpqyfbASjbRKSRKoYk7ju+c9MeYBgDGe3/Zp1KE2+v6Wy2iTh4rhGAAnlUhlYHnJRSFxxwZD/er0r4j2zyaJb3CmUiGfDKv3MEH5mHsQAD/ALR9a8xoooooooooooooooroPBH/ACN9j/20/wDRbV6B47/5J54l/wCwVdf+imr4gr6X+BHxEuNes/8AhFNQh3XGm2ge2uUAAaBCqBGH95dygEdR15GW9K8RaXBcTadqG1VuLW8gw+OWQyKNv5tnv0Pqa3q+AK1PDWmw6z4q0jS7hpFgvb2G3kaMgMFdwpIyCM4Poa+54IIbW3it7eKOGCJAkccahVRQMAADgADjFSUUVn6lrmmaRtF9eRxM2MJyzY552jJxweelc3P8SdNWFjb2V3JL/Csm1FP1IJx+VcvrvjPUNZUwxj7Ja85jjc7nBGCGbjI68YA55zitz4a33/H9YNJ/dmjTb+DHP/fH+c1j/H7ww+teBo9UtoPMutJl81iNxYQMMSYUcHBCMSeioxyOc/PHgvxZeeCvFFrrVmnm+VlJoC5RZo2GGUkfgRnIDBTg4xX2H4X8XaL4x0tL/R72OYFFaWAsBLATkbZEzlTlW9jjIJHNcv4q8ESLM19o0O6NstJbL1Q9coO4/wBkc56ccDg6KKKKKKKKKKKKKK2PCt7Dp/iaxuLhtsQcqzZAC7lK5OegGcn2r2iiisWHXrbUdeTTrC4WQQxmeeRMMjD7oQH6sGJH93Hc4zfidqUOlfDLxFcTrIyPZPbgIATulHlKeSONzgn2z16V8WV0HgT/AJKH4a/7Ctr/AOjVr7fr5/oooooq1p2oT6XqEN7bFRLEcjcMg5GCD9QSK9ygnjubeK4hbdFKgdGxjIIyDzXxR4/0BfC/jzWdHiWNYILgtAiMzBInAeNctySFZQc55B5PWqfhjxPqnhHXIdX0ifyriPhlblJUPVHHdTgfkCCCAR9f+BfHWl+PNDF/YHyriPC3Vo7Ze3c9j6qcHDd8diCBg/ELQ4LVotVt0WMzSbJ1B+85BIYD3wc/h7muFooooooooooooooq5Bq2pW0Kw2+oXcUS/dSOZlUd+ADUn9vax/0Fr7/wIf8AxqOfVtSuYWhuNQu5Ym+8kkzMp78gmu4+GcEi2+o3BX907xorZ6lQxI/8eH51H8bf+SQ67/27/wDpRHXyBVzSdSm0bWbHVLdY2nsriO4jWQEqWRgwBwQcZHqK+868J1O2Sz1W8tYyxSGd41LdSAxAz+VVaKKKKK9c8EamuoeHYYmk3T2v7lwcAgD7vA7bcDJ6lTXin7RPhH7HrFp4rtl/c32La756TKvyNy38SLjAAA8vJ5avD69g/Zx/5KHqH/YKk/8ARsVe/wDjf/kUL7/tn/6MWvH6KKKKKKKKKKKKKKKKK9i8FxvH4RsFkRlJDthhjguxB/EEGud+Nv8AySHXf+3f/wBKI6+QKK+/68P17/kYdT/6+5f/AEM1n0UUUUV0Hg7Wf7H12PzH22tx+6lycAZ6N1A4Pc9ATXsFFFec/ELXILpotKt3WQwyb52A+64BAUH2yc/h7iuFooooooooooooooooqSDyftEX2jzPI3jzPLxu255xnjOK94g8n7PF9n8vyNg8vy8bduOMY4xiuD+Nv/JIdd/7d/8A0ojr5Aor7/rw/Xv+Rh1P/r7l/wDQzWfRRRRRRVyDVtStoVht9Qu4ol+6kczKo78AGpP7e1j/AKC19/4EP/jTZNa1WWNo5NTvHRwVZWnYgg9QRmqNFFFFFFFFFFFFFFFFFFdp8OJ5v7ZuLfzZPI+zs/l7jt3bkGcdM44zVz42/wDJIdd/7d//AEojr5Aor7/rw/Xv+Rh1P/r7l/8AQzWfRRRRRRRRRRRRRRRRRRRRRRRRRRRRXYfDj/kYbj/r0b/0NK0Pjb/ySHXf+3f/ANKI6+QK1NE8N614juPI0bS7u+cOiOYYiyxljhd7dEBweWIHB9K+668N1qRJdd1CSN1dHuZGVlOQQWOCDVGiiiiiiiiiiiiiiiiiiiiiiiiiiiiuu+HUiJ4jlVnVS9syqCcbjuU4HrwCfwr0q+sLPU7OSzv7SC7tZMb4Z4xIjYIIyp4OCAfwrH/4QTwf/wBCpof/AILof/ia6CuJ8VeNLaG1msdLnaS5cAfaIWGxAeuG7nHHHTPXIxXmtFFFFFFFFFFFFFFFFFFFFFFFFFFFFFTWl3PY3UdzbStFNGcq69v8+lb0vjvX5Nm26ji2oFOyFfmP945B5Ptge1R/8Jv4i/6CH/kGP/4mse6v7y92fa7ue42Z2+bIX2564z06Cq9FFFFFFFFFFFFFFFFFFFFFf//Z\n",
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=279x300>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/jpeg": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=160x160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取验证集数据并进行预测\n",
    "# 注意：在PyTorch中，通常在评估模式下一次性处理整个验证集或逐批处理\n",
    "model.eval() # 切换到评估模式\n",
    "val_preds = []\n",
    "with torch.no_grad():\n",
    "    for inputs, _ in val_loader:\n",
    "        inputs = inputs.to(device)\n",
    "        outputs = model(inputs)\n",
    "        # outputs是 (N, C, H, W)，我们需要在通道维度找到最大值的索引\n",
    "        predicted_masks = torch.argmax(outputs, dim=1).cpu().numpy() # (N, H, W)\n",
    "        val_preds.extend(predicted_masks)                                   \n",
    "\n",
    "# 选择一个图像\n",
    "i = 10\n",
    "if val_input_img_paths and val_target_img_paths and val_preds:\n",
    "    display(PILImage.open(val_input_img_paths[i]))\n",
    "    # 展示标注的数据\n",
    "    img = PILImage.open(val_target_img_paths[i]).convert('L')\n",
    "    img = PIL.ImageOps.autocontrast(img)\n",
    "    display(img)\n",
    "\n",
    "    # 显示预测结果\n",
    "    display_mask(i, val_preds, img_size, num_classes)\n",
    "else:\n",
    "    print(\"No validation data or predictions to display.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48900655-b46f-4bdd-aa7e-159f7441f534",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
